home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / DEMOSTORAGE.PY < prev    next >
Encoding:
Python Source  |  1999-08-04  |  20.9 KB  |  613 lines
  1. ##############################################################################
  2. # 
  3. # Zope Public License (ZPL) Version 1.0
  4. # -------------------------------------
  5. # 
  6. # Copyright (c) Digital Creations.  All rights reserved.
  7. # 
  8. # This license has been certified as Open Source(tm).
  9. # 
  10. # Redistribution and use in source and binary forms, with or without
  11. # modification, are permitted provided that the following conditions are
  12. # met:
  13. # 
  14. # 1. Redistributions in source code must retain the above copyright
  15. #    notice, this list of conditions, and the following disclaimer.
  16. # 
  17. # 2. Redistributions in binary form must reproduce the above copyright
  18. #    notice, this list of conditions, and the following disclaimer in
  19. #    the documentation and/or other materials provided with the
  20. #    distribution.
  21. # 
  22. # 3. Digital Creations requests that attribution be given to Zope
  23. #    in any manner possible. Zope includes a "Powered by Zope"
  24. #    button that is installed by default. While it is not a license
  25. #    violation to remove this button, it is requested that the
  26. #    attribution remain. A significant investment has been put
  27. #    into Zope, and this effort will continue if the Zope community
  28. #    continues to grow. This is one way to assure that growth.
  29. # 
  30. # 4. All advertising materials and documentation mentioning
  31. #    features derived from or use of this software must display
  32. #    the following acknowledgement:
  33. # 
  34. #      "This product includes software developed by Digital Creations
  35. #      for use in the Z Object Publishing Environment
  36. #      (http://www.zope.org/)."
  37. # 
  38. #    In the event that the product being advertised includes an
  39. #    intact Zope distribution (with copyright and license included)
  40. #    then this clause is waived.
  41. # 
  42. # 5. Names associated with Zope or Digital Creations must not be used to
  43. #    endorse or promote products derived from this software without
  44. #    prior written permission from Digital Creations.
  45. # 
  46. # 6. Modified redistributions of any form whatsoever must retain
  47. #    the following acknowledgment:
  48. # 
  49. #      "This product includes software developed by Digital Creations
  50. #      for use in the Z Object Publishing Environment
  51. #      (http://www.zope.org/)."
  52. # 
  53. #    Intact (re-)distributions of any official Zope release do not
  54. #    require an external acknowledgement.
  55. # 
  56. # 7. Modifications are encouraged but must be packaged separately as
  57. #    patches to official Zope releases.  Distributions that do not
  58. #    clearly separate the patches from the original work must be clearly
  59. #    labeled as unofficial distributions.  Modifications which do not
  60. #    carry the name Zope may be packaged in any form, as long as they
  61. #    conform to all of the clauses above.
  62. # 
  63. # 
  64. # Disclaimer
  65. # 
  66. #   THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
  67. #   EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68. #   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  69. #   PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
  70. #   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  71. #   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  72. #   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  73. #   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  74. #   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  75. #   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  76. #   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77. #   SUCH DAMAGE.
  78. # 
  79. # 
  80. # This software consists of contributions made by Digital Creations and
  81. # many individuals on behalf of Digital Creations.  Specific
  82. # attributions are listed in the accompanying credits file.
  83. # 
  84. ##############################################################################
  85. """Demo ZODB storage
  86.  
  87. The Demo storage serves two purposes:
  88.  
  89.   - Provide an example implementation of a full storage without
  90.     distracting storage details,
  91.  
  92.   - Provide a volatile storage that is useful for giving demonstrations.
  93.  
  94. The demo strorage can have a "base" storage that is used in a
  95. read-only fashion. The base storage must not not to contain version
  96. data.
  97.  
  98. There are three main data structures:
  99.  
  100.   _data -- Transaction logging information necessary for undo
  101.  
  102.       This is a mapping from transaction id to transaction, where
  103.       a transaction is simply a 4-tuple:
  104.  
  105.         packed, user, description, extension_data, records
  106.  
  107.       where extension_data is a dictionary or None and records are the
  108.       actual records in chronological order. Packed is a flag
  109.       indicating whethe the transaction has been packed or not
  110.  
  111.   _index -- A mapping from oid to record
  112.  
  113.   _vindex -- A mapping from version name to version data
  114.  
  115.       where version data is a mapping from oid to record
  116.  
  117. A record is a tuple:
  118.  
  119.   oid, serial, pre, vdata, p, 
  120.  
  121. where:
  122.  
  123.      oid -- object id
  124.  
  125.      serial -- object serial number
  126.  
  127.      pre -- The previous record for this object (or None)
  128.  
  129.      vdata -- version data
  130.  
  131.         None if not a version, ortherwise:
  132.            version, non-version-record
  133.  
  134.      p -- the pickle data or None
  135.  
  136. The pickle data will be None for a record for an object created in
  137. an aborted version.
  138.  
  139. It is instructive to watch what happens to the internal data structures
  140. as changes are made.  Foe example, in Zope, you can create an external
  141. method::
  142.  
  143.   import Zope
  144.  
  145.   def info(RESPONSE):
  146.       RESPONSE['Content-type']= 'text/plain'
  147.  
  148.       return Zope.DB._storage._splat()
  149.  
  150. and call it to minotor the storage.
  151.  
  152. """
  153. __version__='$Revision: 1.4 $'[11:-2]
  154.  
  155. import base64, POSException, BTree, BaseStorage, time, string, utils
  156. from TimeStamp import TimeStamp
  157. from cPickle import loads
  158.  
  159. class DemoStorage(BaseStorage.BaseStorage):
  160.  
  161.     def __init__(self, name='Demo Storage', base=None, quota=None):
  162.  
  163.         BaseStorage.BaseStorage.__init__(self, name, base)
  164.  
  165.         # We use a BTree because the items are sorted!
  166.         self._data=BTree.BTree()
  167.         self._index={}
  168.         self._vindex={}
  169.         self._base=base
  170.         self._size=0
  171.         self._quota=quota
  172.         self._clear_temp()
  173.         if base is not None and base.versions():
  174.             raise POSException.StorageError, (
  175.                 "Demo base storage has version data")
  176.  
  177.  
  178.     def __len__(self):
  179.         base=self._base
  180.         return (base and len(base) or 0) + len(self._index)
  181.         
  182.     def getSize(self):
  183.         s=100
  184.         for tid, (p, u, d, e, t) in self._data.items():
  185.             s=s+16+24+12+4+16+len(u)+16+len(d)+16+len(e)+16
  186.             for oid, serial, pre, vdata, p in t:
  187.                 s=s+16+24+24+4+4+(p and (16+len(p)) or 4)
  188.                 if vdata: s=s+12+16+len(vdata[0])+4
  189.  
  190.         s=s+16*len(self._index)
  191.  
  192.         for v in self._vindex.values():
  193.             s=s+32+16*len(v)
  194.  
  195.         self._size=s
  196.         return s
  197.  
  198.     def abortVersion(self, src, transaction):
  199.         if transaction is not self._transaction:
  200.             raise POSException.StorageTransactionError(self, transaction)
  201.         
  202.         self._lock_acquire()
  203.         try:
  204.             v=self._vindex.get(src, None)
  205.             if not v: return
  206.             
  207.             tindex=self._tindex
  208.             oids=[]
  209.             for r in v.values():
  210.                 oid, serial, pre, (version, nv), p = r
  211.                 if nv:
  212.                     oids.append(oid)
  213.                     oid, serial, pre, vdata, p = nv
  214.                     tindex.append([oid, serial, r, None, p])
  215.                 else:
  216.                     # effectively, delete the thing
  217.                     tindex.append([oid, None, r, None, None]) 
  218.  
  219.             return oids
  220.  
  221.         finally: self._lock_release()
  222.         
  223.     def commitVersion(self, src, dest, transaction):
  224.         if transaction is not self._transaction:
  225.             raise POSException.StorageTransactionError(self, transaction)
  226.         
  227.         self._lock_acquire()
  228.         try:
  229.             v=self._vindex.get(src, None)
  230.             if v is None: return
  231.             
  232.             tindex=self._tindex
  233.             oids=[]
  234.             for r in v.values():
  235.                 oid, serial, pre, vdata, p = r
  236.                 oids.append(oid)
  237.                 tindex.append([oid, serial, r, None, p])
  238.  
  239.             return oids
  240.  
  241.         finally: self._lock_release()
  242.  
  243.     def load(self, oid, version):
  244.         self._lock_acquire()
  245.         try:
  246.             try: oid, serial, pre, vdata, p = self._index[oid]
  247.             except:
  248.                 if self._base: return self._base.load(oid, '')
  249.                 raise KeyError, oid
  250.  
  251.             if vdata:
  252.                 oversion, nv = vdata
  253.                 if oversion != version:
  254.                     if nv: oid, serial, pre, vdata, p = nv
  255.                     else: raise KeyError, oid
  256.  
  257.             if p is None: raise KeyError, oid
  258.             
  259.             return p, serial
  260.         finally: self._lock_release()
  261.                     
  262.     def modifiedInVersion(self, oid):
  263.         self._lock_acquire()
  264.         try:
  265.             try:
  266.                 oid, serial, pre, vdata, p = self._index[oid]
  267.                 if vdata: return vdata[0]
  268.                 return ''
  269.             except: return ''
  270.         finally: self._lock_release()
  271.  
  272.     def store(self, oid, serial, data, version, transaction):
  273.         if transaction is not self._transaction:
  274.             raise POSException.StorageTransactionError(self, transaction)
  275.  
  276.         self._lock_acquire()
  277.         try:
  278.             old=self._index.get(oid, None)
  279.             if old is None:
  280.                 # Hm, nothing here, check the base version:
  281.                 try: p, oserial = self._base.load(oid, '')
  282.                 except: pass
  283.                 else:
  284.                     old= oid, oserial, None, None, p
  285.             
  286.             nv=None
  287.             if old:
  288.                 oid, oserial, pre, vdata, p = old
  289.                 
  290.                 if vdata:
  291.                     if vdata[0] != version:
  292.                         raise POSException.VersionLockError, oid
  293.                     
  294.                     nv=vdata[1]
  295.                 else:
  296.                     nv=old
  297.  
  298.                 if serial != oserial: raise POSException.ConflictError
  299.                 
  300.             serial=self._serial
  301.             r=[oid, serial, old, version and (version,nv) or None, data]
  302.             self._tindex.append(r)
  303.  
  304.             s=self._tsize
  305.             s=s+72+(data and (16+len(data)) or 4)
  306.             if version: s=s+32+len(version)
  307.  
  308.             if s > self._quota:
  309.                 raise POSException.StorageError, (
  310.                     '''<b>Quota Exceeded</b><br>
  311.                     The maximum quota for this demonstration storage
  312.                     has been exceeded.<br>Have a nice day.''')
  313.  
  314.         finally: self._lock_release()
  315.         return serial
  316.  
  317.     def supportsUndo(self): return 1
  318.     def supportsVersions(self): return 1
  319.  
  320.     def _clear_temp(self):
  321.         self._tindex=[]
  322.         self._tsize=self._size+160
  323.  
  324.     def _begin(self, tid, u, d, e):
  325.         self._tsize=self._size+120+len(u)+len(d)+len(e)
  326.     
  327.     def _finish(self, tid, user, desc, ext):
  328.  
  329.         index=self._index
  330.         tindex=self._tindex
  331.         vindex=self._vindex
  332.  
  333.         self._size=self._tsize
  334.  
  335.         self._data[tid]=None, user, desc, ext, tuple(tindex)
  336.         for r in tindex:
  337.             oid, serial, pre, vdata, p = r
  338.             old=index.get(oid, None)
  339.             if old is not None:
  340.                 oldvdata=old[3]
  341.                 if oldvdata:
  342.                     v=vindex[oldvdata[0]]
  343.                     del v[oid]
  344.                     if not v: del vindex[oldvdata[0]]
  345.                         
  346.             index[oid]=r
  347.             
  348.             if vdata:
  349.                 version=vdata[0]
  350.                 v=vindex.get(version, None)
  351.                 if v is None: v=vindex[version]={}
  352.                 v[oid]=r
  353.  
  354.     def undo(self, transaction_id):
  355.         self._lock_acquire()
  356.         try:
  357.             transaction_id=base64.decodestring(transaction_id+'\n')
  358.             try: t=self._data[transaction_id][4]
  359.             except KeyError:
  360.                 raise UndoError, 'Invalid undo transaction id'
  361.  
  362.             index=self._index
  363.             vindex=self._vindex
  364.             vindex_get=self._vindex.get
  365.             for r in t:
  366.                 if index[r[0]] is not r:
  367.                     raise POSException.UndoError, 'Undoable transaction'
  368.  
  369.             oids=[]
  370.             for r in t:
  371.                 oid, serial, pre, vdata, p = r
  372.                 if pre:
  373.                     
  374.                     index[oid] = pre
  375.                     oids.append(oid)
  376.  
  377.                     # Delete old version data
  378.                     if vdata:
  379.                         version=vdata[0]
  380.                         v=vindex.get(version, None)
  381.                         if v: del v[oid]
  382.  
  383.                     # Add new version data (from pre):
  384.                     oid, serial, prepre, vdata, p = pre
  385.                     if vdata:
  386.                         version=vdata[0]
  387.                         v=vindex.get(version, None)
  388.                         if v is None: v=vindex[version]={}
  389.                         v[oid]=pre
  390.                         
  391.                 else:
  392.                     del index[oid]
  393.                     if vdata:
  394.                         version=vdata[0]
  395.                         v=vindex.get(version, None)
  396.                         if v: del v[oid]
  397.                         if not v: del vindex[version]
  398.  
  399.             del self._data[transaction_id]
  400.  
  401.             return oids
  402.  
  403.         finally: self._lock_release()
  404.  
  405.     def undoLog(self, first, last, filter=None):
  406.         self._lock_acquire()
  407.         try:
  408.             transactions=self._data.items()
  409.             pos=len(transactions)
  410.             encode=base64.encodestring
  411.             r=[]
  412.             append=r.append
  413.             i=0
  414.             while i < last and pos:
  415.                 pos=pos-1
  416.                 if i < first:
  417.                     i = i+1
  418.                     continue
  419.                 tid, (p, u, d, e, t) = transactions[pos]
  420.                 if p: continue
  421.                 d={'id': encode(tid)[:-1],
  422.                    'time': TimeStamp(tid).timeTime(),
  423.                    'user_name': u, 'description': d}
  424.                 if e:
  425.                     d.update(loads(e))
  426.  
  427.                 if filter is None or filter(d):
  428.                     append(d)
  429.                     i=i+1
  430.                 
  431.             return r
  432.         finally: self._lock_release()
  433.  
  434.     def versionEmpty(self, version):
  435.         return not self._vindex.get(version, None)
  436.  
  437.     def versions(self, max=None):
  438.         r=[]
  439.         a=r.append
  440.         for version in self._vindex.keys()[:max]:
  441.             if self.versionEmpty(version): continue
  442.             a(version)
  443.             if max and len(r) >= max: return r
  444.  
  445.         return r
  446.  
  447.     def _build_indexes(self, stop='\377\377\377\377\377\377\377\377'):
  448.         # Rebuild index structures from transaction data
  449.         index={}
  450.         vindex={}
  451.         _data=self._data
  452.         for tid, (p, u, d, e, t) in _data.items():
  453.             if tid >= stop: break
  454.             for r in t:
  455.                 oid, serial, pre, vdata, p = r
  456.                 old=index.get(oid, None)
  457.  
  458.                 if old is not None:
  459.                     oldvdata=old[3]
  460.                     if oldvdata:
  461.                         v=vindex[oldvdata[0]]
  462.                         del v[oid]
  463.                         if not v: del vindex[oldvdata[0]]
  464.                         
  465.                 index[oid]=r
  466.  
  467.                 if vdata:
  468.                     version=vdata[0]
  469.                     v=vindex.get(version, None)
  470.                     if v is None: v=vindex[version]={}
  471.                     vindex[vdata[0]][oid]=r
  472.  
  473.         return index, vindex
  474.  
  475.     def pack(self, t, referencesf):
  476.         # Packing is hard, at least when undo is supported.
  477.         # Even for a simple storage like this one, packing
  478.         # is pretty complex.
  479.         
  480.         self._lock_acquire()
  481.         try:
  482.  
  483.             stop=`apply(TimeStamp, time.gmtime(t)[:5]+(t%60,))`
  484.             _data=self._data
  485.     
  486.             # Build indexes up to the pack time:
  487.             index, vindex = self._build_indexes(stop)
  488.     
  489.             # Now build an index of *only* those objects reachable
  490.             # from the root.
  491.             rootl=['\0\0\0\0\0\0\0\0']
  492.             pop=rootl.pop
  493.             pindex={}
  494.             referenced=pindex.has_key
  495.             while rootl:
  496.                 oid=pop()
  497.                 if referenced(oid): continue
  498.     
  499.                 # Scan non-version pickle for references
  500.                 r=index.get(oid, None)
  501.                 if r is None:
  502.                     # Base storage
  503.                     p, s = self._base.load(oid, '')
  504.                     referencesf(p, rootl)
  505.                 else:
  506.                     pindex[oid]=r
  507.                     oid, serial, pre, vdata, p = r
  508.                     referencesf(p, rootl)
  509.                     if vdata:
  510.                         nv=vdata[1]
  511.                         if nv:
  512.                             oid, serial, pre, vdata, p = nv
  513.                             referencesf(p, rootl)
  514.                 
  515.             # Now we're ready to do the actual packing.
  516.             # We'll simply edit the transaction data in place.
  517.             # We'll defer deleting transactions till the end
  518.             # to avoid messing up the BTree items.
  519.             deleted=[]
  520.             for tid, (p, u, d, e, t) in _data.items():
  521.                 if tid >= stop: break
  522.                 o=[]
  523.                 for r in t:
  524.                     c=pindex.get(r[0])
  525.                     if c is None:
  526.                         # GC this record, no longer referenced
  527.                         continue
  528.                     elif c is not r:
  529.                         # This record is not the indexed record,
  530.                         # so it may not be current. Let's see.
  531.                         oid, serial, pre, vdata, p = r
  532.                         if vdata:
  533.                             # Version record are current *only* if they
  534.                             # are indexed
  535.                             continue 
  536.                         else:
  537.                             # OK, this isn't a version record, so it may be the
  538.                             # non-version record for the indexed record.
  539.                             oid, serial, pre, vdata, p = c
  540.                             if vdata:
  541.                                 if vdata[1] != r:
  542.                                     # This record is not the non-version
  543.                                     # record for the indexed record
  544.                                     continue
  545.                             else:
  546.                                 # The indexed record is not a version record,
  547.                                 # so this record can not be the non-version
  548.                                 # record for it.
  549.                                 continue
  550.                     o.append(r)
  551.                     
  552.                 if o:
  553.                     if len(o) != len(t):
  554.                         _data[tid]=1, u, d, e, tuple(o) # Reset data
  555.                 else:
  556.                     deleted.append(tid)
  557.     
  558.             # Now delete empty transactions
  559.             for tid in deleted: del _data[tid]
  560.     
  561.             # Now reset previous pointers for "current" records:
  562.             for r in pindex.values():
  563.                 r[2]=None # Previous record
  564.                 if r[3]: # vdata
  565.                     r[3][1][2]=None
  566.  
  567.             pindex=None
  568.     
  569.             # Finally, rebuild indexes from transaction data:
  570.             self._index, self._vindex = self._build_indexes()
  571.  
  572.         finally: self._lock_release()
  573.         self.getSize()
  574.  
  575.     def _splat(self):
  576.         """Spit out a string showing state.
  577.         """
  578.         o=[]
  579.  
  580.         o.append('Transactions:')
  581.         for tid, (p, u, d, e, t) in self._data.items():
  582.             o.append("  %s %s" % (TimeStamp(tid), p))
  583.             for r in t:
  584.                 oid, serial, pre, vdata, p = r
  585.                 oid=utils.u64(oid)
  586.                 if serial is not None: serial=str(TimeStamp(serial))
  587.                 pre=id(pre)
  588.                 if vdata and vdata[1]: vdata=vdata[0], id(vdata[1])
  589.                 if p: p=''
  590.                 o.append('    %s: %s' %
  591.                          (id(r), `(oid, serial, pre, vdata, p)`))
  592.  
  593.         o.append('\nIndex:')
  594.         items=self._index.items()
  595.         items.sort()
  596.         for oid, r in items:
  597.             if r: r=id(r)
  598.             o.append('  %s: %s' % (utils.u64(oid), r))
  599.  
  600.         o.append('\nVersion Index:')
  601.         items=self._vindex.items()
  602.         items.sort()
  603.         for version, v in items:
  604.             o.append('  '+version)
  605.             vitems=v.items()
  606.             vitems.sort()
  607.             for oid, r in vitems:
  608.                 if r: r=id(r)
  609.                 o.append('    %s: %s' % (utils.u64(oid), r))
  610.                 
  611.         
  612.         return string.join(o,'\n')
  613.